지도학습의 모든 것

import pandas as pd
import numpy as np
from sklearn.impute import SimpleImputer

# 결측값 확인
df.isnull().sum()

# 방법 1: 결측값이 있는 행 삭제
df_clean = df.dropna()

# 방법 2: 평균값으로 채우기
imputer = SimpleImputer(strategy='mean')
df['age'] = imputer.fit_transform(df[['age']])

# 방법 3: 중앙값으로 채우기 (이상치에 강건)
df['income'].fillna(df['income'].median(), inplace=True)

# 방법 4: 최빈값으로 채우기 (범주형 데이터)
df['city'].fillna(df['city'].mode()[0], inplace=True)

from sklearn.preprocessing import StandardScaler, MinMaxScaler

# 표준화 (가장 많이 사용)
scaler = StandardScaler()
X_train_scaled = scaler.fit_transform(X_train)
X_test_scaled = scaler.transform(X_test)  # ★ test는 transform만!

# Min-Max 정규화
minmax = MinMaxScaler()
X_train_norm = minmax.fit_transform(X_train)
X_test_norm = minmax.transform(X_test)

from sklearn.preprocessing import LabelEncoder, OneHotEncoder
import pandas as pd

# 라벨 인코딩: 순서가 있는 범주에 적합
# (예: 학력 - 고졸:0, 대졸:1, 석사:2)
le = LabelEncoder()
df['education_encoded'] = le.fit_transform(df['education'])

# 원-핫 인코딩: 순서가 없는 범주에 적합
# (예: 도시 - 서울, 부산, 대전)
df_encoded = pd.get_dummies(df, columns=['city'], drop_first=True)

# 결과: city_부산, city_대전 컬럼이 0/1로 생성됨

from sklearn.model_selection import train_test_split

# 80% 학습, 20% 테스트
X_train, X_test, y_train, y_test = train_test_split(
    X, y,
    test_size=0.2,
    random_state=42,     # 재현 가능성을 위한 시드
    stratify=y           # 분류: 클래스 비율 유지
)

from sklearn.linear_model import LinearRegression
from sklearn.metrics import mean_squared_error, r2_score
from sklearn.datasets import fetch_california_housing
from sklearn.model_selection import train_test_split

# 캘리포니아 주택 가격 데이터
data = fetch_california_housing()
X, y = data.data, data.target

X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.2, random_state=42
)

# 모델 학습
model = LinearRegression()
model.fit(X_train, y_train)

# 예측 및 평가
y_pred = model.predict(X_test)
print(f"RMSE: {mean_squared_error(y_test, y_pred, squared=False):.4f}")
print(f"R² Score: {r2_score(y_test, y_pred):.4f}")

# 가중치(계수) 확인
for name, coef in zip(data.feature_names, model.coef_):
    print(f"  {name:12s}: {coef:.4f}")

from sklearn.linear_model import LogisticRegression
from sklearn.datasets import load_breast_cancer
from sklearn.metrics import accuracy_score, classification_report

# 유방암 진단 데이터 (이진 분류)
data = load_breast_cancer()
X_train, X_test, y_train, y_test = train_test_split(
    data.data, data.target, test_size=0.2,
    random_state=42, stratify=data.target
)

# 모델 학습
model = LogisticRegression(max_iter=10000)
model.fit(X_train, y_train)

# 예측 (클래스)
y_pred = model.predict(X_test)

# 예측 (확률) - 스팸 확률 87% 같은 값
y_prob = model.predict_proba(X_test)[:, 1]

print(f"정확도: {accuracy_score(y_test, y_pred):.4f}")
print(classification_report(y_test, y_pred,
      target_names=data.target_names))

from sklearn.tree import DecisionTreeClassifier, plot_tree
from sklearn.datasets import load_iris
import matplotlib.pyplot as plt

# 붓꽃 데이터
iris = load_iris()
X_train, X_test, y_train, y_test = train_test_split(
    iris.data, iris.target, test_size=0.2, random_state=42
)

# 결정 트리 (깊이 제한으로 과적합 방지)
tree = DecisionTreeClassifier(
    max_depth=3,
    criterion='gini',
    random_state=42
)
tree.fit(X_train, y_train)

print(f"정확도: {tree.score(X_test, y_test):.4f}")

# 트리 시각화
plt.figure(figsize=(16, 8))
plot_tree(tree, feature_names=iris.feature_names,
          class_names=iris.target_names, filled=True)
plt.show()

from sklearn.ensemble import RandomForestClassifier

# 랜덤 포레스트: 100개 트리의 앙상블
rf = RandomForestClassifier(
    n_estimators=100,      # 트리 수
    max_depth=10,           # 각 트리의 최대 깊이
    random_state=42,
    n_jobs=-1               # 모든 CPU 코어 사용
)
rf.fit(X_train, y_train)
print(f"정확도: {rf.score(X_test, y_test):.4f}")

# 특성 중요도 확인
import pandas as pd
importance = pd.Series(rf.feature_importances_,
                       index=feature_names)
importance.sort_values(ascending=False).head(10).plot.barh()
plt.title('Feature Importance')
plt.show()

# XGBoost
from xgboost import XGBClassifier

xgb = XGBClassifier(
    n_estimators=200,
    max_depth=6,
    learning_rate=0.1,
    random_state=42,
    use_label_encoder=False,
    eval_metric='logloss'
)
xgb.fit(X_train, y_train)
print(f"XGBoost 정확도: {xgb.score(X_test, y_test):.4f}")

# LightGBM
from lightgbm import LGBMClassifier

lgbm = LGBMClassifier(
    n_estimators=200,
    max_depth=-1,       # 제한 없음
    learning_rate=0.1,
    random_state=42,
    verbose=-1
)
lgbm.fit(X_train, y_train)
print(f"LightGBM 정확도: {lgbm.score(X_test, y_test):.4f}")

from sklearn.svm import SVC
from sklearn.preprocessing import StandardScaler
from sklearn.pipeline import Pipeline

# SVM은 스케일링이 필수! Pipeline으로 편리하게 처리
svm_pipeline = Pipeline([
    ('scaler', StandardScaler()),
    ('svm', SVC(
        kernel='rbf',      # RBF 커널
        C=1.0,             # 정규화 파라미터
        gamma='scale',     # 커널 계수
        probability=True   # 확률 출력 활성화
    ))
])

svm_pipeline.fit(X_train, y_train)
print(f"SVM 정확도: {svm_pipeline.score(X_test, y_test):.4f}")

from sklearn.neighbors import KNeighborsClassifier

# 최적 K 탐색
best_k, best_score = 1, 0
for k in range(1, 21, 2):
    knn = KNeighborsClassifier(n_neighbors=k)
    knn.fit(X_train_scaled, y_train)
    score = knn.score(X_test_scaled, y_test)
    if score > best_score:
        best_k, best_score = k, score
    print(f"K={k:2d} → 정확도: {score:.4f}")

print(f"\n최적 K={best_k}, 정확도={best_score:.4f}")

from sklearn.naive_bayes import GaussianNB, MultinomialNB
from sklearn.feature_extraction.text import CountVectorizer

# 1. 수치 데이터 → Gaussian NB
gnb = GaussianNB()
gnb.fit(X_train, y_train)
print(f"GaussianNB 정확도: {gnb.score(X_test, y_test):.4f}")

# 2. 텍스트 데이터 → Multinomial NB (스팸 필터 예시)
texts = ["무료 쿠폰 지금 받으세요", "내일 회의 참석 가능하세요?",
         "당첨 축하합니다 상금 수령", "프로젝트 보고서 검토 부탁드립니다"]
labels = [1, 0, 1, 0]  # 1: 스팸, 0: 정상

vectorizer = CountVectorizer()
X_text = vectorizer.fit_transform(texts)

mnb = MultinomialNB()
mnb.fit(X_text, labels)

# 새 이메일 분류
new_email = vectorizer.transform(["무료 상금 당첨 축하"])
print(f"스팸 확률: {mnb.predict_proba(new_email)[0][1]:.2%}")

from sklearn.neural_network import MLPClassifier

# scikit-learn의 다층 퍼셉트론 (간편 버전)
mlp = MLPClassifier(
    hidden_layer_sizes=(128, 64),   # 은닉층: 128개 → 64개 뉴런
    activation='relu',              # 활성화 함수
    solver='adam',                  # 최적화 알고리즘
    max_iter=500,                  # 최대 에포크
    early_stopping=True,           # 조기 종료 (과적합 방지)
    validation_fraction=0.1,       # 검증 데이터 10%
    random_state=42
)
mlp.fit(X_train_scaled, y_train)
print(f"MLP 정확도: {mlp.score(X_test_scaled, y_test):.4f}")

# 학습 곡선 확인
import matplotlib.pyplot as plt
plt.plot(mlp.loss_curve_, label='Training Loss')
plt.xlabel('Epoch')
plt.ylabel('Loss')
plt.title('MLP Learning Curve')
plt.legend()
plt.show()

import torch
import torch.nn as nn

# PyTorch로 간단한 분류 신경망 정의
class SimpleNet(nn.Module):
    def __init__(self, input_dim, num_classes):
        super().__init__()
        self.network = nn.Sequential(
            nn.Linear(input_dim, 128),
            nn.ReLU(),
            nn.Dropout(0.3),       # 과적합 방지
            nn.Linear(128, 64),
            nn.ReLU(),
            nn.Dropout(0.2),
            nn.Linear(64, num_classes)
        )

    def forward(self, x):
        return self.network(x)

# 모델 생성
model = SimpleNet(input_dim=10, num_classes=2)
criterion = nn.CrossEntropyLoss()
optimizer = torch.optim.Adam(model.parameters(), lr=0.001)

from sklearn.model_selection import learning_curve
import numpy as np
import matplotlib.pyplot as plt

# 학습 곡선으로 과적합 진단
train_sizes, train_scores, val_scores = learning_curve(
    model, X_train, y_train,
    train_sizes=np.linspace(0.1, 1.0, 10),
    cv=5, scoring='accuracy'
)

plt.figure(figsize=(8, 5))
plt.plot(train_sizes, train_scores.mean(axis=1), label='Train')
plt.plot(train_sizes, val_scores.mean(axis=1), label='Validation')
plt.xlabel('Training Set Size')
plt.ylabel('Accuracy')
plt.title('Learning Curve - 과적합 진단')
plt.legend()
plt.grid(True, alpha=0.3)
plt.show()

# 두 곡선의 간격이 크면 → 과적합
# 두 곡선 모두 낮으면 → 과소적합
# 두 곡선이 높고 가까우면 → 적절한 적합 ✓

from sklearn.linear_model import Ridge, Lasso, ElasticNet

# Ridge (L2 정규화)
ridge = Ridge(alpha=1.0)  # alpha: 정규화 강도
ridge.fit(X_train, y_train)
print(f"Ridge R²: {ridge.score(X_test, y_test):.4f}")

# Lasso (L1 정규화)
lasso = Lasso(alpha=0.01)
lasso.fit(X_train, y_train)
print(f"Lasso R²: {lasso.score(X_test, y_test):.4f}")

# 0이 된 가중치 개수 확인 (Lasso의 특성 선택 효과)
print(f"전체 특성 수: {len(lasso.coef_)}")
print(f"Lasso가 제거한 특성 수: {(lasso.coef_ == 0).sum()}")
print(f"살아남은 특성 수: {(lasso.coef_ != 0).sum()}")

# ElasticNet (L1 + L2 혼합)
enet = ElasticNet(alpha=0.01, l1_ratio=0.5)
enet.fit(X_train, y_train)
print(f"ElasticNet R²: {enet.score(X_test, y_test):.4f}")

# alpha 값에 따른 성능 변화 실험
for alpha in [0.001, 0.01, 0.1, 1.0, 10.0]:
    ridge = Ridge(alpha=alpha)
    ridge.fit(X_train, y_train)
    print(f"  alpha={alpha:6.3f} → R²={ridge.score(X_test, y_test):.4f}")

from sklearn.metrics import (
    confusion_matrix, classification_report,
    roc_auc_score, roc_curve, precision_recall_curve
)
import matplotlib.pyplot as plt

# 혼동 행렬
cm = confusion_matrix(y_test, y_pred)
print("혼동 행렬:")
print(cm)

# 종합 분류 보고서 (Precision, Recall, F1 한번에)
print("\n분류 보고서:")
print(classification_report(y_test, y_pred,
      target_names=['음성', '양성']))

# AUC-ROC 곡선 시각화
y_prob = model.predict_proba(X_test)[:, 1]
auc = roc_auc_score(y_test, y_prob)
fpr, tpr, thresholds = roc_curve(y_test, y_prob)

plt.figure(figsize=(8, 6))
plt.plot(fpr, tpr, color='#ff6b35',
         label=f'Model (AUC = {auc:.4f})', linewidth=2)
plt.plot([0, 1], [0, 1], 'k--', label='Random (AUC = 0.5)', alpha=0.5)
plt.xlabel('False Positive Rate (1 - 특이도)')
plt.ylabel('True Positive Rate (재현율)')
plt.title('ROC Curve')
plt.legend(loc='lower right')
plt.grid(True, alpha=0.3)
plt.show()

from sklearn.metrics import (
    mean_squared_error, mean_absolute_error, r2_score
)
import numpy as np

y_pred = model.predict(X_test)

mse  = mean_squared_error(y_test, y_pred)
rmse = np.sqrt(mse)
mae  = mean_absolute_error(y_test, y_pred)
r2   = r2_score(y_test, y_pred)

print(f"MSE  : {mse:,.2f}")
print(f"RMSE : {rmse:,.2f}")
print(f"MAE  : {mae:,.2f}")
print(f"R²   : {r2:.4f}")

from sklearn.model_selection import cross_val_score, StratifiedKFold

# 가장 간단한 교차 검증
scores = cross_val_score(
    model, X, y,
    cv=5,              # 5-Fold
    scoring='accuracy'  # 평가 지표
)
print(f"평균 정확도: {scores.mean():.4f} (±{scores.std():.4f})")
print(f"각 Fold 점수: {scores}")

# 분류: Stratified K-Fold (클래스 비율 유지) ★추천
skf = StratifiedKFold(n_splits=5, shuffle=True, random_state=42)
scores = cross_val_score(model, X, y, cv=skf, scoring='f1')
print(f"평균 F1: {scores.mean():.4f} (±{scores.std():.4f})")

# 여러 지표를 동시에 평가
from sklearn.model_selection import cross_validate

results = cross_validate(
    model, X, y, cv=5,
    scoring=['accuracy', 'f1', 'roc_auc']
)
for metric in ['test_accuracy', 'test_f1', 'test_roc_auc']:
    vals = results[metric]
    print(f"{metric:18s}: {vals.mean():.4f} (±{vals.std():.4f})")

from sklearn.model_selection import (
    LeaveOneOut, TimeSeriesSplit, RepeatedStratifiedKFold
)

# 시계열 교차 검증
tscv = TimeSeriesSplit(n_splits=5)
scores = cross_val_score(model, X, y, cv=tscv, scoring='neg_mean_squared_error')

# 반복 교차 검증 (더 안정적인 추정)
rskf = RepeatedStratifiedKFold(n_splits=5, n_repeats=3, random_state=42)
scores = cross_val_score(model, X, y, cv=rskf, scoring='f1')
print(f"반복 CV (5-Fold × 3회 = 15회): {scores.mean():.4f} (±{scores.std():.4f})")

from sklearn.model_selection import GridSearchCV
from sklearn.ensemble import RandomForestClassifier

# 탐색할 하이퍼파라미터 격자 정의
param_grid = {
    'n_estimators': [100, 200, 300],
    'max_depth': [5, 10, 15, None],
    'min_samples_split': [2, 5, 10]
}
# 총 조합: 3 × 4 × 3 = 36가지 × 5-Fold = 180번 학습

grid_search = GridSearchCV(
    RandomForestClassifier(random_state=42),
    param_grid,
    cv=5,             # 5-Fold 교차 검증
    scoring='f1',     # 최적화할 지표
    n_jobs=-1,         # 모든 CPU 코어 사용 (병렬 처리)
    verbose=1          # 진행 상황 출력
)
grid_search.fit(X_train, y_train)

print(f"최적 파라미터: {grid_search.best_params_}")
print(f"최고 CV F1: {grid_search.best_score_:.4f}")

# 최적 모델로 테스트 셋 평가
best_model = grid_search.best_estimator_
print(f"테스트 정확도: {best_model.score(X_test, y_test):.4f}")

from sklearn.model_selection import RandomizedSearchCV
from scipy.stats import randint, uniform

# 연속적인 분포에서 샘플링 가능!
param_dist = {
    'n_estimators': randint(50, 500),       # 50~500 정수 중 랜덤
    'max_depth': randint(3, 30),             # 3~30 정수 중 랜덤
    'learning_rate': uniform(0.01, 0.29),   # 0.01~0.30 실수 균등분포
    'min_samples_split': randint(2, 20),
    'subsample': uniform(0.6, 0.4)          # 0.6~1.0
}

random_search = RandomizedSearchCV(
    GradientBoostingClassifier(random_state=42),
    param_dist,
    n_iter=100,   # 100번만 랜덤 시도
    cv=5,
    scoring='f1',
    random_state=42,
    n_jobs=-1,
    verbose=1
)
random_search.fit(X_train, y_train)

print(f"최적 파라미터: {random_search.best_params_}")
print(f"최고 CV F1: {random_search.best_score_:.4f}")

import optuna
from sklearn.model_selection import cross_val_score

def objective(trial):
    # Optuna가 지능적으로 값을 제안
    params = {
        'n_estimators': trial.suggest_int('n_estimators', 50, 500),
        'max_depth': trial.suggest_int('max_depth', 3, 15),
        'learning_rate': trial.suggest_float('learning_rate', 0.01, 0.3, log=True),
        'min_samples_split': trial.suggest_int('min_samples_split', 2, 20),
    }
    model = GradientBoostingClassifier(**params, random_state=42)
    score = cross_val_score(model, X_train, y_train, cv=5, scoring='f1')
    return score.mean()

study = optuna.create_study(direction='maximize')
study.optimize(objective, n_trials=100, show_progress_bar=True)

print(f"최적 파라미터: {study.best_params}")
print(f"최고 F1: {study.best_value:.4f}")

import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
import seaborn as sns
from sklearn.model_selection import train_test_split, cross_val_score
from sklearn.preprocessing import StandardScaler
from sklearn.metrics import classification_report, roc_auc_score

# 데이터 로드 (seaborn 내장 데이터)
df = sns.load_dataset('titanic')
print(f"데이터 크기: {df.shape}")  # (891, 15)
print(f"\n결측값:\n{df.isnull().sum()}")

# 타겟 변수 분포 확인
print(f"\n생존율:\n{df['survived'].value_counts(normalize=True)}")
# 0 (사망): 61.6%  |  1 (생존): 38.4%

# 주요 특성별 생존율 탐색
print(f"\n성별 생존율:\n{df.groupby('sex')['survived'].mean()}")
# female: 74.2%  |  male: 18.9%

print(f"\n좌석 등급별 생존율:\n{df.groupby('pclass')['survived'].mean()}")
# 1등석: 63.0%  |  2등석: 47.3%  |  3등석: 24.2%

# 사용할 특성 선택
features = ['pclass', 'sex', 'age', 'sibsp', 'parch', 'fare', 'embarked']
target = 'survived'

df_ml = df[features + [target]].copy()

# ── 결측값 처리 ──
# age: 177건 결측 → 중앙값으로 채우기 (이상치에 강건)
df_ml['age'].fillna(df_ml['age'].median(), inplace=True)
# embarked: 2건 결측 → 최빈값으로 채우기
df_ml['embarked'].fillna(df_ml['embarked'].mode()[0], inplace=True)

# ── 특성 공학 (Feature Engineering) ──
# 가족 크기 = 형제/배우자 + 부모/자녀 + 본인
df_ml['family_size'] = df_ml['sibsp'] + df_ml['parch'] + 1
# 혼자 탑승 여부
df_ml['is_alone'] = (df_ml['family_size'] == 1).astype(int)

# ── 범주형 인코딩 ──
df_ml = pd.get_dummies(df_ml, columns=['sex', 'embarked'], drop_first=True)

# ── 특성/타겟 분리 ──
X = df_ml.drop(target, axis=1)
y = df_ml[target]

print(f"특성: {list(X.columns)}")
print(f"데이터 크기: X={X.shape}, y={y.shape}")

# ── 데이터 분할 ──
X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.2, random_state=42, stratify=y
)

# ── 스케일링 (SVM, KNN용) ──
scaler = StandardScaler()
X_train_scaled = scaler.fit_transform(X_train)
X_test_scaled = scaler.transform(X_test)

from sklearn.linear_model import LogisticRegression
from sklearn.tree import DecisionTreeClassifier
from sklearn.ensemble import (
    RandomForestClassifier, GradientBoostingClassifier
)
from sklearn.svm import SVC
from sklearn.neighbors import KNeighborsClassifier

# 비교할 모델 딕셔너리
models = {
    'Logistic Regression': (LogisticRegression(max_iter=1000), False),
    'Decision Tree': (DecisionTreeClassifier(max_depth=5), False),
    'Random Forest': (RandomForestClassifier(n_estimators=200), False),
    'Gradient Boosting': (GradientBoostingClassifier(n_estimators=200), False),
    'SVM (RBF)': (SVC(kernel='rbf', probability=True), True),
    'KNN (k=7)': (KNeighborsClassifier(n_neighbors=7), True),
}

print(f"{'모델':<25s} {'CV 평균':>8s}  {'CV 표준편차':>10s}")
print("─" * 50)

results = {}
for name, (model, needs_scaling) in models.items():
    X_cv = X_train_scaled if needs_scaling else X_train
    scores = cross_val_score(model, X_cv, y_train, cv=5, scoring='accuracy')
    results[name] = scores
    print(f"{name:<25s} {scores.mean():8.4f}  {scores.std():10.4f}")

from sklearn.model_selection import GridSearchCV

# Gradient Boosting이 가장 좋았으므로 정밀 튜닝
param_grid = {
    'n_estimators': [100, 200, 300],
    'max_depth': [3, 4, 5],
    'learning_rate': [0.01, 0.05, 0.1],
    'min_samples_split': [2, 5]
}

grid = GridSearchCV(
    GradientBoostingClassifier(random_state=42),
    param_grid,
    cv=5,
    scoring='accuracy',
    n_jobs=-1,
    verbose=1
)
grid.fit(X_train, y_train)

print(f"최적 파라미터: {grid.best_params_}")
print(f"최적 CV 점수: {grid.best_score_:.4f}")

# ── 최종 테스트 평가 ──
best = grid.best_estimator_
y_pred = best.predict(X_test)
y_prob = best.predict_proba(X_test)[:, 1]

print("\n══════ 최종 테스트 결과 ══════")
print(classification_report(y_test, y_pred,
      target_names=['사망', '생존']))
print(f"AUC-ROC: {roc_auc_score(y_test, y_prob):.4f}")

# 어떤 특성이 생존에 가장 큰 영향을 미쳤는가?
importance = pd.Series(
    best.feature_importances_,
    index=X.columns
).sort_values(ascending=True)

plt.figure(figsize=(9, 6))
importance.plot.barh(color='#ff6b35', edgecolor='#333')
plt.title('Feature Importance - 타이타닉 생존 예측', fontsize=14)
plt.xlabel('Importance')
plt.tight_layout()
plt.show()

# ── 인사이트 ──
# 1. sex_male (성별): 가장 큰 영향. 여성이 남성보다 생존율 훨씬 높음
# 2. fare (운임): 높은 운임 = 높은 등급 = 높은 생존율
# 3. age (나이): 어린아이 우선 구조 정책 반영
# 4. pclass (좌석 등급): 1등석 >> 2등석 >> 3등석 생존율
# → "여성과 아이 우선(Women and Children First)" 정책이 데이터로 증명됨

# =============================================
#  지도학습 치트시트 - 핵심 코드 한눈에 보기
# =============================================

# ── 1. 데이터 분할 ──
from sklearn.model_selection import train_test_split
X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.2, random_state=42, stratify=y)

# ── 2. 전처리 ──
from sklearn.preprocessing import StandardScaler, MinMaxScaler
scaler = StandardScaler()
X_train_s = scaler.fit_transform(X_train)
X_test_s  = scaler.transform(X_test)  # ★ transform만!

# ── 3. 모델 학습 (공통 패턴) ──
model.fit(X_train, y_train)          # 학습
y_pred = model.predict(X_test)       # 예측 (클래스)
y_prob = model.predict_proba(X_test) # 예측 (확률)
model.score(X_test, y_test)          # 정확도

# ── 4. 주요 모델 import ──
from sklearn.linear_model import LinearRegression, Ridge, Lasso
from sklearn.linear_model import LogisticRegression
from sklearn.tree import DecisionTreeClassifier
from sklearn.ensemble import RandomForestClassifier
from sklearn.ensemble import GradientBoostingClassifier
from sklearn.svm import SVC, SVR
from sklearn.neighbors import KNeighborsClassifier
from sklearn.naive_bayes import GaussianNB
from sklearn.neural_network import MLPClassifier
from xgboost import XGBClassifier, XGBRegressor
from lightgbm import LGBMClassifier, LGBMRegressor

# ── 5. 분류 평가 지표 ──
from sklearn.metrics import (
    accuracy_score, precision_score, recall_score,
    f1_score, roc_auc_score, classification_report,
    confusion_matrix
)

# ── 6. 회귀 평가 지표 ──
from sklearn.metrics import (
    mean_squared_error, mean_absolute_error, r2_score
)

# ── 7. 교차 검증 ──
from sklearn.model_selection import cross_val_score
scores = cross_val_score(model, X, y, cv=5, scoring='accuracy')
print(f"{scores.mean():.4f} ± {scores.std():.4f}")

# ── 8. 하이퍼파라미터 튜닝 ──
from sklearn.model_selection import GridSearchCV, RandomizedSearchCV
grid = GridSearchCV(model, param_grid, cv=5, scoring='f1', n_jobs=-1)
grid.fit(X_train, y_train)
best = grid.best_estimator_
print(grid.best_params_, grid.best_score_)

# ── 9. 파이프라인 (전처리 + 모델 일체화) ──
from sklearn.pipeline import Pipeline
pipe = Pipeline([
    ('scaler', StandardScaler()),
    ('model', SVC(kernel='rbf'))
])
pipe.fit(X_train, y_train)
pipe.score(X_test, y_test)

# ── 10. 특성 중요도 (트리 기반 모델) ──
import pandas as pd
importance = pd.Series(model.feature_importances_, index=feature_names)
importance.sort_values(ascending=False).head(10)